/***********************************************************
 * TraceExpression.c
 *
 *  Created on: 2009/08/19
 *  Author:
 *  CopyRight: ------
 *  役割り：
 ***********************************************************/

#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include "../tracedef.h"
#include "TraceAst.h"


static S4 traceAssignExp ( VOID );
static S4 traceUnaryExp( VOID );
static S4 tracePostfixExp( VOID );
static S4 traceCastExp( VOID );
static S4 traceCommaExp( VOID );
static S4 traceCondExp( VOID );

static S4 traceParenExp( VOID );
static S4 traceArithExp( VOID );
static S4 traceShiftExp ( VOID );
static S4 traceRelaExp ( VOID );
static S4 traceBitExp( VOID );
static S4 traceLogiExp( VOID );

/******************************************************************
* 関 数 名 : 	traceSubsExp
* 機    能 : 	トレース代入式
* 引    数 : 	なし
* 戻 り 値 :	TRACEEXIT_FATAL
* 			TRACEEXIT_END
*			TRACEEXIT_SUCCESS
* 詳細内容 :
*******************************************************************/
static S4 traceAssignExp ( VOID )
{
	AST astExp = 0;
	U4 ulKind = 0;


	/* 戻り値をTRACEEXIT_SUCCESSとする */
	S4 iRet = TRACEEXIT_SUCCESS;

	astExp = stCurrTraceInfo.astTable;
	ulKind = CExpression.getOpKind( astExp );
	if( CExpressionOpKind.isAssignmentOp( ulKind )){
		if( CAssignOpKind.isAssignment( ulKind ) ){
			if(lEventSec & EVT_PREEXPR)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astExp ,lEvent | EVT_PREEXPR );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
			stCurrTraceInfo.astTable = CExpression.getRightNode( astExp );
			iRet = TraceExp();
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}

			/* 「カレントトレース対象」を左の子ノードとする */
			stCurrTraceInfo.astTable = CExpression.getLeftNode( astExp );
			iRet = TraceExp();
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}

			/* 戻り値 = 規約起動関数pfuncコール; */
			if(lEventSec & EVT_EXPRESSION)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astExp , lEvent | EVT_EXPRESSION );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
		}else{
			if(lEventSec & EVT_PREEXPR)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astExp ,lEvent | EVT_PREEXPR );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
			stCurrTraceInfo.astTable = CExpression.getRightNode( astExp );
			iRet = TraceExp();
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}

			/* 「カレントトレース対象」を左の子ノードとする */
			stCurrTraceInfo.astTable = CExpression.getLeftNode( astExp );
			iRet = TraceExp();
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}

			/* 戻り値 = 規約起動関数pfuncコール; */
			if(lEventSec & EVT_EXPRESSION)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astExp , lEvent | EVT_EXPRESSION );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
		}
	}
	return iRet;
}



/******************************************************************
* 関 数 名 : 	S4 traceUnaryExp( VOID )
* 機    能 : 	トレース単項式
* 引    数 : 	なし
* 戻 り 値 :	TRACEEXIT_SUCCESS
*			TRACEEXIT_FATAL
* 			TRACEEXIT_END
* 詳細内容 :
*******************************************************************/
static S4 traceUnaryExp( VOID )
{
	S4 iRet = 0;
	U4 ulNodeKind = 0;
	AST astExp = 0;

	/*戻り値をTRACEEXIT_SUCCESSとする*/
	iRet = TRACEEXIT_SUCCESS;
	astExp = stCurrTraceInfo.astTable;
	ulNodeKind = CExpression.getOpKind( astExp );

	if( CExpressionOpKind.isUnaryOp( ulNodeKind )){
		if(lEventSec & EVT_PREEXPR)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astExp ,lEvent | EVT_PREEXPR );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		/*「カレントトレース対象」を子ノードとする */
		stCurrTraceInfo.astTable = CExpression.getLeftNode( astExp );

		iRet = TraceExp();
		if( iRet > TRACEEXIT_WARNING )
		{
			return iRet;
		}

		if(lEventSec & EVT_EXPRESSION)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astExp ,lEvent | EVT_EXPRESSION );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
	}
	return iRet;
}
/******************************************************************
* 関 数 名 : 	S4 tracePostfixExp( VOID )
* 機    能 : 	トレース後置式
* 引    数 : 	なし
* 戻 り 値 :	TRACEEXIT_SUCCESS
*			TRACEEXIT_FATAL
* 			TRACEEXIT_END
* 詳細内容 :
*******************************************************************/
static S4 tracePostfixExp( VOID )
{
	S4 iRet = 0;
	U4 ulNodeKind = 0;
	AST astExp = 0;

	/*戻り値をTRACEEXIT_SUCCESSとする*/
	iRet = TRACEEXIT_SUCCESS;

	/*switch(演算種類) */
	astExp = stCurrTraceInfo.astTable;
	ulNodeKind = CExpression.getOpKind( astExp );
	if( CExpressionOpKind.isPostfixOp( ulNodeKind ) ){
		if( CPostfixOpKind.isPostIncrement( ulNodeKind ) ){
			if(lEventSec & EVT_PREEXPR)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astExp ,lEvent | EVT_PREEXPR );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
			stCurrTraceInfo.astTable = CExpression.getLeftNode( astExp );
			iRet = TraceExp();
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
			if(lEventSec & EVT_EXPRESSION)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astExp , lEvent | EVT_EXPRESSION );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
		}else if( CPostfixOpKind.isPostDecrement( ulNodeKind ) ){
			if(lEventSec & EVT_PREEXPR)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astExp ,lEvent | EVT_PREEXPR );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
			stCurrTraceInfo.astTable = CExpression.getLeftNode( astExp );
			iRet = TraceExp();
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
			if(lEventSec & EVT_EXPRESSION)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astExp , lEvent | EVT_EXPRESSION );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
		}else if( CPostfixOpKind.isArrayCall( ulNodeKind ) ){
			if(lEventSec & EVT_PREEXPR)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astExp ,lEvent | EVT_PREEXPR );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
			stCurrTraceInfo.astTable = CExpression.getLeftNode( astExp );

			iRet = TraceExp();
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
			stCurrTraceInfo.astTable = CExpression.getRightNode( astExp );
			iRet = TraceExp();
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}

			if(lEventSec & EVT_EXPRESSION)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astExp , lEvent | EVT_EXPRESSION );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
		}else if( CPostfixOpKind.isFunctionCall( ulNodeKind ) ){
			if(lEventSec & EVT_PREEXPR)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astExp ,lEvent | EVT_PREEXPR );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
			stCurrTraceInfo.astTable = CExpression.getLeftNode( astExp );
			iRet = TraceExp();
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
			stCurrTraceInfo.astTable = CExpression.getRightNode( astExp );
			if( stCurrTraceInfo.astTable ){
				iRet = TraceExp();
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
			if(lEventSec & EVT_EXPRESSION)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astExp , lEvent | EVT_EXPRESSION );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
		}else if( CPostfixOpKind.isArrow( ulNodeKind ) ){
			if(lEventSec & EVT_PREEXPR)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astExp ,lEvent | EVT_PREEXPR );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
			stCurrTraceInfo.astTable = CExpression.getLeftNode( astExp );
			iRet = TraceExp();
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
			if(lEventSec & EVT_EXPRESSION)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astExp , lEvent | EVT_EXPRESSION );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
		}else if( CPostfixOpKind.isDot( ulNodeKind ) ){
			if(lEventSec & EVT_PREEXPR)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astExp ,lEvent | EVT_PREEXPR );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
			stCurrTraceInfo.astTable = CExpression.getLeftNode( astExp );
			iRet = TraceExp();
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
			if(lEventSec & EVT_EXPRESSION)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astExp , lEvent | EVT_EXPRESSION );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
		}else if( CPostfixOpKind.isCompoundLiterals( ulNodeKind ) ){
			if(lEventSec & EVT_PREEXPR)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astExp ,lEvent | EVT_PREEXPR );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
			stCurrTraceInfo.astTable = CExpression.getLeftNode( astExp );
			iRet = TraceExp();
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
			stCurrTraceInfo.astTable = CExpression.getRightNode( astExp );
			iRet = TraceExp();
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
			if(lEventSec & EVT_EXPRESSION)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astExp , lEvent | EVT_EXPRESSION );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
		}
	}
	return iRet;
}



/******************************************************************
* 関 数 名 :traceCastExp
* 機    能 : トレースキャスト式
* 引    数 :なし
* 戻 り 値 :TRACEEXIT_SUCCESS
* 		 TRACEEXIT_END
*        TRACEEXIT_FATAL
* 詳細内容 :
*******************************************************************/
static S4 traceCastExp( VOID )
{
	S4 iRet = TRACEEXIT_SUCCESS; /*戻り値をTRACEEXIT_SUCCESSとする*/
	U4 ulTempKind = 0;  /*演算種類*/
	AST astTable = 0;

	stCurrTraceInfo.usKind = TR_KIND_EXPRESSION;
	astTable = stCurrTraceInfo.astTable;

	ulTempKind = CExpression.getOpKind( astTable );
	if( CExpressionOpKind.isCastOp( ulTempKind ) ){
		if(lEventSec & EVT_PREEXPR)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astTable ,lEvent | EVT_PREEXPR );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		stCurrTraceInfo.astTable = CExpression.getLeftNode( astTable );

		iRet = TraceExp( );
		if( iRet > TRACEEXIT_WARNING )
		{
			return iRet;
		}
		stCurrTraceInfo.astTable = CExpression.getRightNode( astTable );

		iRet = TraceExp( );
		if( iRet > TRACEEXIT_WARNING )
		{
			return iRet;
		}

		if(lEventSec & EVT_EXPRESSION)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astTable , lEvent | EVT_EXPRESSION );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
	}
	return iRet;
}



/******************************************************************
* 関 数 名 :traceCommaExp
* 機    能 :トレースコンマ演算式
* 引    数 :なし
* 戻 り 値 :TRACEEXIT_SUCCESS
* 		 TRACEEXIT_END
*        TRACEEXIT_FATAL
* 詳細内容 :
*******************************************************************/
static S4 traceCommaExp( VOID )
{
	S4 iRet = TRACEEXIT_SUCCESS; /*戻り値をTRACEEXIT_SUCCESSとする*/
	U4 ulTempKind = 0;  /*演算種類*/
	AST astTable = 0;

	stCurrTraceInfo.usKind = TR_KIND_EXPRESSION;
	astTable = stCurrTraceInfo.astTable;
	ulTempKind = CExpression.getOpKind( astTable );
	if( CExpressionOpKind.isCommaOp( ulTempKind ) ){
		if(lEventSec & EVT_PREEXPR)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astTable ,lEvent | EVT_PREEXPR );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		stCurrTraceInfo.astTable = CExpression.getLeftNode( astTable );
		iRet = TraceExp( );
		if( iRet > TRACEEXIT_WARNING )
		{
			return iRet;
		}
		stCurrTraceInfo.astTable = CExpression.getRightNode( astTable );
		iRet = TraceExp( );
		if( iRet > TRACEEXIT_WARNING )
		{
			return iRet;
		}

		if(lEventSec & EVT_EXPRESSION)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astTable , lEvent | EVT_EXPRESSION );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
	}
	return iRet;
}

/******************************************************************
* 関 数 名 :traceArgExp
* 機    能 :トレースコンマ演算式
* 引    数 :なし
* 戻 り 値 :TRACEEXIT_SUCCESS
* 		 TRACEEXIT_END
*        TRACEEXIT_FATAL
* 詳細内容 :
*******************************************************************/
static S4 traceArgExp( VOID )
{
	S4 iRet = TRACEEXIT_SUCCESS; /*戻り値をTRACEEXIT_SUCCESSとする*/
	U4 ulTempKind = 0;  /*演算種類*/
	AST astTable = 0;

	stCurrTraceInfo.usKind = TR_KIND_EXPRESSION;
	astTable = stCurrTraceInfo.astTable;
	ulTempKind = CExpression.getOpKind( astTable );
	if( CExpressionOpKind.isCommaOp( ulTempKind ) ){
		if(lEventSec & EVT_PREEXPR)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astTable ,lEvent | EVT_PREEXPR );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		stCurrTraceInfo.astTable = CExpression.getLeftNode( astTable );
		iRet = TraceExp( );
		if( iRet > TRACEEXIT_WARNING )
		{
			return iRet;
		}
		stCurrTraceInfo.astTable = CExpression.getRightNode( astTable );
		iRet = TraceExp( );
		if( iRet > TRACEEXIT_WARNING )
		{
			return iRet;
		}

		if(lEventSec & EVT_EXPRESSION)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astTable , lEvent | EVT_EXPRESSION );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
	}
	return iRet;
}

/******************************************************************
* 関 数 名 :traceExpCondOp
* 機    能 :トレース三項演算子演算式
* 引    数 :なし
* 戻 り 値 :TRACEEXIT_SUCCESS
* 		 TRACEEXIT_END
*        TRACEEXIT_FATAL
* 詳細内容 :
*******************************************************************/
static S4 traceExpCondOp( AST astExp )
{
//	AST astMaxstack;
	S4 iRet;
	stCurrTraceInfo.astTable = CExpression.getRightNode( astExp );
	if( stCurrTraceInfo.astTable < MIN_ARRAY )
	{
		return TRACEEXIT_SUCCESS;
	}
//	astMaxstack = stTraceStackAccess.getMax();
	iRet = TraceStack( STACK_PUSH );
	if( iRet != TRACEEXIT_SUCCESS )
	{
		return iRet;
	}
	return traceCondExp();
}

/******************************************************************
* 関 数 名 :traceCondExp
* 機    能 :トレース三項演算子演算式
* 引    数 :なし
* 戻 り 値 :TRACEEXIT_SUCCESS
* 		 TRACEEXIT_END
*        TRACEEXIT_FATAL
* 詳細内容 :
*******************************************************************/
static S4 traceCondExp( VOID )
{
	S4 iRet = TRACEEXIT_SUCCESS; /*戻り値をTRACEEXIT_SUCCESSとする*/
	U4 ulTempKind = 0;  /*演算種類*/
	AST astTable = 0;
	AST astTemp = 0;
	AST astMaxstack = 0;
	U2 usTimes = 0;
	U2 usRet;

	stCurrTraceInfo.usKind = TR_KIND_EXPRESSION;
	astTable = stCurrTraceInfo.astTable;
	ulTempKind = CExpression.getOpKind( astTable );
	if( CExpressionOpKind.isConditionalOp( ulTempKind ) ){
		if( CConditionOpKind.isQuestionOp( ulTempKind ) ){
			if(lEventSec & EVT_PREEXPR)
			{
				iRet = pfunc( TR_KIND_EXPRESSION, astTable ,lEvent | EVT_PREEXPR );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
			}
		    stCurrTraceInfo.astTable = CExpression.getLeftNode( astTable );

		    /*再帰コールTraceExp( )*/
		    iRet = TraceExp( );
		    if( iRet > TRACEEXIT_WARNING )
		    {
		    	return iRet;
		    }
		    if( gblIsSearching == FALSE )
		    {
				iRet = traceExpCondOp( astTable );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
		    }
		}else{


			/* if(STACKの最上テーブル != カレントトレース対象) */
			astMaxstack = stTraceStackAccess.getMax();
			usRet = stTraceStackAccess.kind.get(astMaxstack);
			astTemp = stTraceStackAccess.currObject.get(astMaxstack);
			if (stCurrTraceInfo.astTable != astTemp
					|| stCurrTraceInfo.usKind != usRet) {
				iRet = TraceStack(STACK_PUSH);
				if (iRet != TRACEEXIT_SUCCESS) {
					return (iRet);
				}
			}

			astMaxstack = stTraceStackAccess.getMax( );
			usTimes = stTraceStackAccess.times.get( astMaxstack );
			if( usTimes == 0 ){
				/*「カレントトレース対象」を左の子ノードとする*/
				stCurrTraceInfo.astTable = CExpression.getLeftNode( astTable );
				iRet = TraceExp( );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
				stCurrTraceInfo.astTable = 0;
				stCurrTraceInfo.astNext = 0;
				stTraceStackAccess.times.set( astMaxstack, 10 );
				iRet = TRACEEXIT_END;
			}else if ( usTimes == 10 ){
				astTemp = CExpression.getRightNode( stCurrTraceInfo.astTable );
				stCurrTraceInfo.astTable = CExpression.getLeftNode( astTemp );
				iRet = TraceExp( );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
				stCurrTraceInfo.astTable = 0;
				stCurrTraceInfo.astNext = 0;
				stTraceStackAccess.times.set( astMaxstack, 11);
			}else if( usTimes == 11 ){
				astTemp = CExpression.getRightNode( stCurrTraceInfo.astTable );
				stCurrTraceInfo.astTable = CExpression.getRightNode( astTemp );
				iRet = TraceExp( );
				if( iRet > TRACEEXIT_WARNING )
				{
					return iRet;
				}
				stCurrTraceInfo.astTable = 0;
				stCurrTraceInfo.astNext = 0;
				stTraceStackAccess.times.set( astMaxstack, 12);
			}else{
				stCurrTraceInfo.astTable = 0;
				stCurrTraceInfo.astNext = 0;
				stTraceStackAccess.times.set( astMaxstack, TRACE_OBJECT_END );
			}
		}
	}
    return iRet;
}
/**************************************************************************
* 関 数 名 :	traceParenExp
* 機    能 : 	トレース一次式
* 引 き 数 :	VOID
* 戻 り 値 : 	success:	TRACEEXIT_SUCCESS
* 			end:		TRACEEXIT_END
* 			error:		TRACEEXIT_FATAL
* 詳細内容 :
************************************************************************/
static S4 traceParenExp( VOID )
{
	S4 iRet = 0;
	AST astCnt = 0;
	U4 ulNodeKind = 0;

	/* 戻り値をTRACEEXIT_SUCCESSとする */
	iRet = TRACEEXIT_SUCCESS;

	astCnt = stCurrTraceInfo.astTable;
	ulNodeKind = CExpression.getOpKind( astCnt );
	if( CExpressionOpKind.isParentheseExp( ulNodeKind ) ){
		if(lEventSec & EVT_PREEXPR)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astCnt ,lEvent | EVT_PREEXPR );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		stCurrTraceInfo.astTable = CExpression.getLeftNode( astCnt );
		iRet = TraceExp ();
		if( iRet > TRACEEXIT_WARNING )
		{
			return iRet;
		}
		if(lEventSec & EVT_EXPRESSION)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astCnt , lEvent | EVT_EXPRESSION );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
	}
	return iRet;
}

/**************************************************************************
* 関 数 名 :	traceArithExp
* 機    能 : 	トレース一次式
* 引 き 数 :	VOID
* 戻 り 値 : 	success:	TRACEEXIT_SUCCESS
* 			end:		TRACEEXIT_END
* 			error:		TRACEEXIT_FATAL
* 詳細内容 :
************************************************************************/
static S4 traceArithExp( VOID )
{
	S4 iRet = 0;
	U4 ulSet = 0;
	AST astExp = 0;


	iRet = TRACEEXIT_SUCCESS;
	astExp = stCurrTraceInfo.astTable;
	ulSet = CExpression.getOpKind( astExp );
	if( CExpressionOpKind.isMultiplicativeOp( ulSet )
		|| CExpressionOpKind.isAdditiveOp( ulSet ) ){
		if(lEventSec & EVT_PREEXPR)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astExp ,lEvent | EVT_PREEXPR );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		stCurrTraceInfo.astTable = CExpression.getLeftNode( astExp );
		iRet = TraceExp( );
		if( iRet > TRACEEXIT_WARNING )
		{
			return iRet;
		}
		stCurrTraceInfo.astTable = CExpression.getRightNode( astExp );
		iRet = TraceExp( );
		if( iRet > TRACEEXIT_WARNING )
		{
			return iRet;
		}
		if(lEventSec & EVT_EXPRESSION)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astExp  , lEvent | EVT_EXPRESSION );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
	}
	return iRet;
}
/**************************************************************************
* 関 数 名 :	traceShiftExp
* 機    能 : 	トレースシフト演算式
* 引 き 数 :	VOID
* 戻 り 値 : 	success:	TRACEEXIT_SUCCESS
* 			end:		TRACEEXIT_END
* 			error:		TRACEEXIT_FATAL
* 詳細内容 :
************************************************************************/
static S4 traceShiftExp ( VOID )
{
	S4 iRet = 0;
	AST astExp = 0;
	U4 ulSet = 0;

	iRet = TRACEEXIT_SUCCESS;
	astExp = stCurrTraceInfo.astTable;
	ulSet = CExpression.getOpKind( astExp );
	if( CExpressionOpKind.isShiftOp( ulSet ) ){
		if(lEventSec & EVT_PREEXPR)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astExp ,lEvent | EVT_PREEXPR );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		stCurrTraceInfo.astTable = CExpression.getLeftNode( astExp );
		iRet = TraceExp( );
		if( iRet > TRACEEXIT_WARNING )
		{
			return iRet;
		}
		stCurrTraceInfo.astTable = CExpression.getRightNode( astExp );
		iRet = TraceExp( );
		if( iRet > TRACEEXIT_WARNING )
		{
			return iRet;
		}
		if(lEventSec & EVT_EXPRESSION)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astExp  , lEvent | EVT_EXPRESSION );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
	}
	return iRet;
}

/**************************************************************************
* 関 数 名 :	traceRelaExp
* 機    能 : 	トレース関係演算式
* 引 き 数 :	VOID
* 戻 り 値 : 	success:	TRACEEXIT_SUCCESS
* 			end:		TRACEEXIT_END
* 			error:		TRACEEXIT_FATAL
* 詳細内容 :
************************************************************************/
static S4 traceRelaExp ( VOID )
{

	S4 iRet = 0;
	AST astExp = 0;
	U4 ulTemp = 0;

	/* 戻り値をTRACEEXIT_SUCCESSとする */
	iRet = TRACEEXIT_SUCCESS;

	astExp = stCurrTraceInfo.astTable;
	ulTemp = CExpression.getOpKind( astExp );
	if( CExpressionOpKind.isRelationalOp( ulTemp )
		|| CExpressionOpKind.isEqualityOp( ulTemp ) ){
		if(lEventSec & EVT_PREEXPR)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astExp ,lEvent | EVT_PREEXPR );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		stCurrTraceInfo.astTable = CExpression.getLeftNode( astExp );
		iRet = TraceExp( );
		if( iRet > TRACEEXIT_WARNING )
		{
			return iRet;
		}
		stCurrTraceInfo.astTable = CExpression.getRightNode( astExp );
		iRet = TraceExp( );
		if( iRet > TRACEEXIT_WARNING )
		{
			return iRet;
		}
		if(lEventSec & EVT_EXPRESSION)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astExp  , lEvent | EVT_EXPRESSION );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
	}
	return iRet;
}

 /**************************************************************************
* 関 数 名 :	traceBitExp
* 機    能 : 	トレース一次式
* 引 き 数 :	VOID
* 戻 り 値 : 	success:	TRACEEXIT_SUCCESS
* 			end:		TRACEEXIT_END
* 			error:		TRACEEXIT_FATAL
* 詳細内容 :
************************************************************************/
static S4 traceBitExp( VOID )
{

	S4 iRet = 0;
	AST astExp = 0;
	U4 ulTemp = 0;

	/* 戻り値をTRACEEXIT_SUCCESSとする */
	iRet = TRACEEXIT_SUCCESS;

	astExp = stCurrTraceInfo.astTable;
	ulTemp = CExpression.getOpKind( astExp );
	if( CExpressionOpKind.isBitwiseAndOp( ulTemp )
		|| CExpressionOpKind.isBitwiseExclusiveOrOp( ulTemp )
		|| CExpressionOpKind.isBitwiseInclusiveOrOp( ulTemp )){
		if(lEventSec & EVT_PREEXPR)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astExp ,lEvent | EVT_PREEXPR );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		stCurrTraceInfo.astTable = CExpression.getLeftNode( astExp );
		iRet = TraceExp( );
		if( iRet > TRACEEXIT_WARNING )
		{
			return iRet;
		}
		stCurrTraceInfo.astTable = CExpression.getRightNode( astExp );
		iRet = TraceExp( );
		if( iRet > TRACEEXIT_WARNING )
		{
			return iRet;
		}
		if(lEventSec & EVT_EXPRESSION)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astExp  , lEvent | EVT_EXPRESSION );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
	}
	return iRet;
}

 /**************************************************************************
* 関 数 名 :	traceLogiExp
* 機    能 : 	トレース一次式
* 引 き 数 :	VOID
* 戻 り 値 : 	success:	TRACEEXIT_SUCCESS
* 			end:		TRACEEXIT_END
* 			error:		TRACEEXIT_FATAL
* 詳細内容 :
************************************************************************/
static S4 traceLogiExp( VOID )
{
	S4 iRet = 0;
	AST astExp = 0;
	U4 ulTemp = 0;

	/* 戻り値をTRACEEXIT_SUCCESSとする */
	iRet = TRACEEXIT_SUCCESS;

	astExp = stCurrTraceInfo.astTable;
	ulTemp = CExpression.getOpKind( astExp );
	if( CExpressionOpKind.isLogicalAndOp( ulTemp )
		|| CExpressionOpKind.isLogicalOrOp( ulTemp ) ){
		if(lEventSec & EVT_PREEXPR)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astExp ,lEvent | EVT_PREEXPR );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		stCurrTraceInfo.astTable = CExpression.getLeftNode( astExp );
		iRet = TraceExp( );
		if( iRet > TRACEEXIT_WARNING )
		{
			return iRet;
		}
		stCurrTraceInfo.astTable = CExpression.getRightNode( astExp );
		iRet = TraceExp( );
		if( iRet > TRACEEXIT_WARNING )
		{
			return iRet;
		}
		if(lEventSec & EVT_EXPRESSION)
		{
			iRet = pfunc( TR_KIND_EXPRESSION, astExp  , lEvent | EVT_EXPRESSION );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
	}
	return iRet;

}
/******************************************************************
* 関 数 名 : traceConstantExp
* 機    能 : 	定数
* 引    数 : なし
* 戻 り 値 :TRACEEXIT_SUCCESS
* 		 TRACEEXIT_END
*        TRACEEXIT_FATAL
* 詳細内容 :
*******************************************************************/

static S4  traceConstantExp( VOID )
{
	U4 ulKind = 0;
	AST astExp = 0;

	S4 iRet = TRACEEXIT_SUCCESS;

	astExp = stCurrTraceInfo.astTable;
	ulKind = CExpression.getOpKind( astExp );
	if( CExpressionOpKind.isConstantNumber( ulKind ) )
	{
		/* 戻り値 = 規約起動関数pfuncコール */
		if(lEventSec & EVENT_TRPREEXPR)
		{
			iRet = pfunc( stCurrTraceInfo.usKind, stCurrTraceInfo.astTable , lEvent | EVENT_TRPREEXPR );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		if(lEventSec & EVT_EXPRESSION)
		{
			iRet = pfunc( stCurrTraceInfo.usKind, stCurrTraceInfo.astTable , lEvent | EVT_EXPRESSION );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		/*debug,12/11/13,S*/
		stCurrTraceInfo.astTable = 0;
		stCurrTraceInfo.astNext = 0;
		/*debug,12/11/13,E*/
	}
	return ( iRet );
}
/******************************************************************
* 関 数 名 : traceConstantStringExp
* 機    能 : 	文字列
* 引    数 : なし
* 戻 り 値 :TRACEEXIT_SUCCESS
* 		 TRACEEXIT_END
*        TRACEEXIT_FATAL
* 詳細内容 :
*******************************************************************/

static S4  traceConstantStringExp( VOID )
{
	U4 ulKind = 0;
	AST astExp = 0;

	S4 iRet = TRACEEXIT_SUCCESS;

	astExp = stCurrTraceInfo.astTable;
	ulKind = CExpression.getOpKind( astExp );
	if( CExpressionOpKind.isConstString( ulKind ) )
	{
		/* 戻り値 = 規約起動関数pfuncコール */
		if(lEventSec & EVENT_TRPREEXPR)
		{
			iRet = pfunc( stCurrTraceInfo.usKind, stCurrTraceInfo.astTable , lEvent | EVENT_TRPREEXPR );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		if(lEventSec & EVT_EXPRESSION)
		{
			iRet = pfunc( stCurrTraceInfo.usKind, stCurrTraceInfo.astTable , lEvent | EVT_EXPRESSION );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		/*debug,12/11/13,S*/
		stCurrTraceInfo.astTable = 0;
		stCurrTraceInfo.astNext = 0;
		/*debug,12/11/13,E*/
	}
	return ( iRet );
}
/******************************************************************
* 関 数 名 : traceIdentifierExp
* 機    能 : 	識別子
* 引    数 : なし
* 戻 り 値 :TRACEEXIT_SUCCESS
* 		 TRACEEXIT_END
*        TRACEEXIT_FATAL
* 詳細内容 :
*******************************************************************/

static S4  traceIdentifierExp( VOID )
{
	U4 ulKind = 0;
	AST astExp = 0;

	S4 iRet = TRACEEXIT_SUCCESS;

	astExp = stCurrTraceInfo.astTable;
	ulKind = CExpression.getOpKind( astExp );
	if( CExpressionOpKind.isIdentifier( ulKind ) )
	{
		/* 戻り値 = 規約起動関数pfuncコール */
		if(lEventSec & EVENT_TRPREEXPR)
		{
			iRet = pfunc( stCurrTraceInfo.usKind, stCurrTraceInfo.astTable , lEvent | EVENT_TRPREEXPR );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		if(lEventSec & EVT_EXPRESSION)
		{
			iRet = pfunc( stCurrTraceInfo.usKind, stCurrTraceInfo.astTable , lEvent | EVT_EXPRESSION );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		/*debug,12/11/13,S*/
		stCurrTraceInfo.astTable = 0;
		stCurrTraceInfo.astNext = 0;
		/*debug,12/11/13,E*/
	}
	return ( iRet );
}
/******************************************************************
* 関 数 名 : traceIdentifierExp
* 機    能 : 	識別子
* 引    数 : なし
* 戻 り 値 :TRACEEXIT_SUCCESS
* 		 TRACEEXIT_END
*        TRACEEXIT_FATAL
* 詳細内容 :
*******************************************************************/

static S4  traceDeclarationExp( VOID )
{
	U4 ulKind = 0;
	AST astExp = 0;

	S4 iRet = TRACEEXIT_SUCCESS;

	astExp = stCurrTraceInfo.astTable;
	ulKind = CExpression.getOpKind( astExp );
	if( CExpressionOpKind.isIdentifier( ulKind ) )
	{
		/* 戻り値 = 規約起動関数pfuncコール */
		if(lEventSec & EVENT_TRPREEXPR)
		{
			iRet = pfunc( stCurrTraceInfo.usKind, stCurrTraceInfo.astTable , lEvent | EVENT_TRPREEXPR );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		if(lEventSec & EVT_EXPRESSION)
		{
			iRet = pfunc( stCurrTraceInfo.usKind, stCurrTraceInfo.astTable , lEvent | EVT_EXPRESSION );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		/*debug,12/11/13,S*/
		stCurrTraceInfo.astTable = 0;
		stCurrTraceInfo.astNext = 0;
		/*debug,12/11/13,E*/
	}
	return ( iRet );
}
/******************************************************************
* 関 数 名 : traceStatementExp
* 機    能 : 	識別子
* 引    数 : なし
* 戻 り 値 :TRACEEXIT_SUCCESS
* 		 TRACEEXIT_END
*        TRACEEXIT_FATAL
* 詳細内容 :
*******************************************************************/

static S4  traceStatementExp( VOID )
{
	U4 ulKind = 0;
	AST astExp = 0;

	S4 iRet = TRACEEXIT_SUCCESS;

	astExp = stCurrTraceInfo.astTable;
	ulKind = CExpression.getOpKind( astExp );
	if( CExpressionOpKind.isIdentifier( ulKind ) )
	{
		/* 戻り値 = 規約起動関数pfuncコール */
		if(lEventSec & EVENT_TRPREEXPR)
		{
			iRet = pfunc( stCurrTraceInfo.usKind, stCurrTraceInfo.astTable , lEvent | EVENT_TRPREEXPR );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		if(lEventSec & EVT_EXPRESSION)
		{
			iRet = pfunc( stCurrTraceInfo.usKind, stCurrTraceInfo.astTable , lEvent | EVT_EXPRESSION );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		/*debug,12/11/13,S*/
		stCurrTraceInfo.astTable = 0;
		stCurrTraceInfo.astNext = 0;
		/*debug,12/11/13,E*/
	}
	return ( iRet );
}
/******************************************************************
* 関 数 名 : traceInitializerExp
* 機    能 : 	識別子
* 引    数 : なし
* 戻 り 値 :TRACEEXIT_SUCCESS
* 		 TRACEEXIT_END
*        TRACEEXIT_FATAL
* 詳細内容 :
*******************************************************************/

static S4  traceInitializerExp( VOID )
{
	U4 ulKind = 0;
	AST astExp = 0;

	S4 iRet = TRACEEXIT_SUCCESS;

	astExp = stCurrTraceInfo.astTable;
	ulKind = CExpression.getOpKind( astExp );
	if( CExpressionOpKind.isIdentifier( ulKind ) )
	{
		/* 戻り値 = 規約起動関数pfuncコール */
		if(lEventSec & EVENT_TRPREEXPR)
		{
			iRet = pfunc( stCurrTraceInfo.usKind, stCurrTraceInfo.astTable , lEvent | EVENT_TRPREEXPR );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		if(lEventSec & EVT_EXPRESSION)
		{
			iRet = pfunc( stCurrTraceInfo.usKind, stCurrTraceInfo.astTable , lEvent | EVT_EXPRESSION );
			if( iRet > TRACEEXIT_WARNING )
			{
				return iRet;
			}
		}
		/*debug,12/11/13,S*/
		stCurrTraceInfo.astTable = 0;
		stCurrTraceInfo.astNext = 0;
		/*debug,12/11/13,E*/
	}
	return ( iRet );
}
/******************************************************************
* 関 数 名 :TraceExp
* 機    能 : トレース式
* 引    数 :なし
* 戻 り 値 :TRACEEXIT_SUCCESS
* 		 TRACEEXIT_END
*        TRACEEXIT_FATAL
* 詳細内容 :
*******************************************************************/
S4 TraceExp( VOID )
{
	S4 iRet = TRACEEXIT_SUCCESS;/*戻り値をTRACEEXIT_SUCCESSとする*/
	U4 ulTempKind = 0;/*演算種類*/
	AST astMaxKind = 0;

	astMaxKind = CExpression.getMax();
	/*if（式が空 || 式の「連番」>演算式最大添字）*/
	if( stCurrTraceInfo.astTable < MIN_ARRAY || stCurrTraceInfo.astTable > astMaxKind )
	{
		return iRet;/*戻り値をreturn*/
	}
	ulTempKind = CExpression.getOpKind( stCurrTraceInfo.astTable );
	if( CExpressionOpKind.isConstantNumber( ulTempKind ) ){
		iRet = traceConstantExp( );
	}else if( CExpressionOpKind.isConstString( ulTempKind ) ){
		iRet = traceConstantStringExp( );
	}else if( CExpressionOpKind.isIdentifier( ulTempKind ) ){
		iRet = traceIdentifierExp( );
	}else if( CExpressionOpKind.isDeclaration( ulTempKind ) ){
		iRet = traceDeclarationExp( );
	}else if( CExpressionOpKind.isStatement( ulTempKind ) ){
		iRet = traceStatementExp( );
	}else if( CExpressionOpKind.isInitializer( ulTempKind ) ){
		iRet = traceInitializerExp( );
	}else if( CExpressionOpKind.isParentheseExp( ulTempKind ) ){
		iRet = traceParenExp( );
	}else if( CExpressionOpKind.isPostfixOp( ulTempKind ) ){
		iRet = tracePostfixExp( );
	}else if( CExpressionOpKind.isUnaryOp( ulTempKind ) ){
		iRet = traceUnaryExp( );
	}else if( CExpressionOpKind.isCastOp( ulTempKind ) ){
		iRet = traceCastExp( );
	}else if( CExpressionOpKind.isMultiplicativeOp( ulTempKind )){
		iRet = traceArithExp( );
	}else if( CExpressionOpKind.isAdditiveOp( ulTempKind )){
		iRet = traceArithExp( );
	}else if( CExpressionOpKind.isShiftOp( ulTempKind )){
		iRet = traceShiftExp( );
	}else if( CExpressionOpKind.isRelationalOp( ulTempKind )){
		iRet = traceRelaExp( );
	}else if( CExpressionOpKind.isEqualityOp( ulTempKind )){
		iRet = traceRelaExp( );
	}else if( CExpressionOpKind.isBitwiseAndOp( ulTempKind )){
		iRet = traceBitExp( );
	}else if( CExpressionOpKind.isBitwiseExclusiveOrOp( ulTempKind )){
		iRet = traceBitExp( );
	}else if( CExpressionOpKind.isBitwiseInclusiveOrOp( ulTempKind )){
		iRet = traceBitExp( );
	}else if( CExpressionOpKind.isLogicalAndOp( ulTempKind )){
		iRet = traceLogiExp( );
	}else if( CExpressionOpKind.isLogicalOrOp( ulTempKind )){
		iRet = traceLogiExp( );
	}else if( CExpressionOpKind.isConditionalOp( ulTempKind )){
		iRet = traceCondExp( );
	}else if( CExpressionOpKind.isAssignmentOp( ulTempKind )){
		iRet = traceAssignExp( );
	}else if( CExpressionOpKind.isArgumentDelimiter( ulTempKind )){
		iRet = traceArgExp( );
	}else if( CExpressionOpKind.isCommaOp( ulTempKind ) ){
		iRet = traceCommaExp( );
	}
	return iRet;
}
S4 TraceExpEntry( VOID ){
	return TraceExp();
}
/* end of file */
